#ifndef _CoordinateMatrix_h
#define _CoordinateMatrix_h

#include "CxxUtils.h"
#include "LangUtils.h"

class DoOpCoordinateMatrix
{
public: 
	class ds_matrix : public _DoOperator
	{
	protected: 
		ds_matrix(const ds_matrix &);
		ds_matrix& operator=(const ds_matrix &);
	public: 
		ds_matrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_initmatrix : public _DoOperator
	{
	protected: 
		ds_initmatrix(const ds_initmatrix &);
		ds_initmatrix& operator=(const ds_initmatrix &);
	public: 
		ds_initmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_identmatrix : public _DoOperator
	{
	protected: 
		ds_identmatrix(const ds_identmatrix &);
		ds_identmatrix& operator=(const ds_identmatrix &);
	public: 
		ds_identmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_defaultmatrix : public _DoOperator
	{
	protected: 
		ds_defaultmatrix(const ds_defaultmatrix &);
		ds_defaultmatrix& operator=(const ds_defaultmatrix &);
	public: 
		ds_defaultmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_currentmatrix : public _DoOperator
	{
	protected: 
		ds_currentmatrix(const ds_currentmatrix &);
		ds_currentmatrix& operator=(const ds_currentmatrix &);
	public: 
		ds_currentmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_setmatrix : public _DoOperator
	{
	protected: 
		ds_setmatrix(const ds_setmatrix &);
		ds_setmatrix& operator=(const ds_setmatrix &);
	public: 
		ds_setmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_translate : public _DoOperator
	{
	protected: 
		ds_translate(const ds_translate &);
		ds_translate& operator=(const ds_translate &);
	public: 
		ds_translate() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_scale : public _DoOperator
	{
	protected: 
		ds_scale(const ds_scale &);
		ds_scale& operator=(const ds_scale &);
	public: 
		ds_scale() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rotate : public _DoOperator
	{
	protected: 
		ds_rotate(const ds_rotate &);
		ds_rotate& operator=(const ds_rotate &);
	public: 
		ds_rotate() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_concat : public _DoOperator
	{
	protected: 
		ds_concat(const ds_concat &);
		ds_concat& operator=(const ds_concat &);
	public: 
		ds_concat() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_concatmatrix : public _DoOperator
	{
	protected: 
		ds_concatmatrix(const ds_concatmatrix &);
		ds_concatmatrix& operator=(const ds_concatmatrix &);
	public: 
		ds_concatmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_transform : public _DoOperator
	{
	protected: 
		ds_transform(const ds_transform &);
		ds_transform& operator=(const ds_transform &);
	public: 
		ds_transform() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_dtransform : public _DoOperator
	{
	protected: 
		ds_dtransform(const ds_dtransform &);
		ds_dtransform& operator=(const ds_dtransform &);
	public: 
		ds_dtransform() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_itransform : public _DoOperator
	{
	protected: 
		ds_itransform(const ds_itransform &);
		ds_itransform& operator=(const ds_itransform &);
	public: 
		ds_itransform() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_idtransform : public _DoOperator
	{
	protected: 
		ds_idtransform(const ds_idtransform &);
		ds_idtransform& operator=(const ds_idtransform &);
	public: 
		ds_idtransform() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_invertmatrix : public _DoOperator
	{
	protected: 
		ds_invertmatrix(const ds_invertmatrix &);
		ds_invertmatrix& operator=(const ds_invertmatrix &);
	public: 
		ds_invertmatrix() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	static void push(_DoDictionaryMultimap& dict) {
		dict.put(CRefPtr< _DoObject >(new DoName("matrix")), CRefPtr< _DoObject >(new ds_matrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("initmatrix")), CRefPtr< _DoObject >(new ds_initmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("identmatrix")), CRefPtr< _DoObject >(new ds_identmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("defaultmatrix")), CRefPtr< _DoObject >(new ds_defaultmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("currentmatrix")), CRefPtr< _DoObject >(new ds_currentmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("setmatrix")), CRefPtr< _DoObject >(new ds_setmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("translate")), CRefPtr< _DoObject >(new ds_translate()));
		dict.put(CRefPtr< _DoObject >(new DoName("scale")), CRefPtr< _DoObject >(new ds_scale()));
		dict.put(CRefPtr< _DoObject >(new DoName("rotate")), CRefPtr< _DoObject >(new ds_rotate()));
		dict.put(CRefPtr< _DoObject >(new DoName("concat")), CRefPtr< _DoObject >(new ds_concat()));
		dict.put(CRefPtr< _DoObject >(new DoName("concatmatrix")), CRefPtr< _DoObject >(new ds_concatmatrix()));
		dict.put(CRefPtr< _DoObject >(new DoName("transform")), CRefPtr< _DoObject >(new ds_transform()));
		dict.put(CRefPtr< _DoObject >(new DoName("dtransform")), CRefPtr< _DoObject >(new ds_dtransform()));
		dict.put(CRefPtr< _DoObject >(new DoName("itransform")), CRefPtr< _DoObject >(new ds_itransform()));
		dict.put(CRefPtr< _DoObject >(new DoName("idtransform")), CRefPtr< _DoObject >(new ds_idtransform()));
		dict.put(CRefPtr< _DoObject >(new DoName("invertmatrix")), CRefPtr< _DoObject >(new ds_invertmatrix()));
	}
};

#endif
